This doesn't really address the duplication though, does it? There are still two copies of AliasThis present, and every time a new AST node is introduced it must still be defined twice.

The only way we could eliminate the duplication would be to have the ASTCodegen classes inherit from the ASTBase classes, however, that would require multiple inheritance since a node must inherit its parse time counterpart but also its logical ancestor (for example AddExp would need to inherit ParseTimeAddExp and BinaryExp). This could technically be done by using inheritance and alias this, but I would rather not go there since this currently isn't defined behavior (and ideally alias this would be deprecated for classes).

Instead, this PR limits the scope of the duplication. Indeed, new AST node declarations still need to be duplicated, but I would argue that this doesn't happen very often.

I couldn't come up with a solution that doesn't require to refactor the compiler entirely (e.g. stripping all AST nodes of their functions, basically transforming them into data containers) . If anyone has any propositions, I'm open to suggestions. However, I doubt that a feasible solution to get rid of the duplicated AST node declarations is possible at this point.

I couldn't come up with a solution that doesn't require to refactor the compiler entirely (e.g. stripping all AST nodes of their functions, basically transforming them into data containers) . If anyone has any propositions, I'm open to suggestions. However, I doubt that a feasible solution to get rid of the duplicated AST node declarations is possible at this point.

Why not? We've already removed the semantic, semantic2, semantic3, resolve, toIR, toCtype, toElem, toDt, and probably many more this way.

1. There are pointless member functions:
   

   dmd/src/dmd/statement.d

   Lines 216 to 249 in 0ff19fb

   	final bool usesEH()
   	{
   	extern (C++) final class UsesEH : StoppableVisitor
   	{
   	alias visit = typeof(super).visit;
   	public:
   	override void visit(Statement s)
   	{
   	}
   	override void visit(TryCatchStatement s)
   	{
   	stop = true;
   	}
   	override void visit(TryFinallyStatement s)
   	{
   	stop = true;
   	}
   	override void visit(ScopeGuardStatement s)
   	{
   	stop = true;
   	}
   	override void visit(SynchronizedStatement s)
   	{
   	stop = true;
   	}
   	}
   	scope UsesEH ueh = new UsesEH();
   	return walkPostorder(this, ueh);
   	}

2. There doesn't need to be a big clear-out done, just anything that isn't to do with examining itself. e.g. from Statement:
   

   dmd/src/dmd/statement.h

   Lines 119 to 129 in 0ff19fb

   	virtual Statement *getRelatedLabeled() { return this; }
   	virtual bool hasBreak() const;
   	virtual bool hasContinue() const;
   	bool usesEH();
   	bool comeFrom();
   	bool hasCode();
   	virtual Statement *scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally);
   	virtual Statements *flatten(Scope *sc);
   	virtual Statement *last();
   	virtual ReturnStatement *endsWithReturnStatement() { return NULL; }

   
   Remove the above highlighted functions, and astbase can just publicly import dmd.statement...

Unfortunately, it's not that easy. Looking at statement.d it imports a lot of modules that don't have anything to do with parsing. Before being able to import statement.d we need to get rid of all of those dependencies. That is no easy task and it requires a lot of refactorings.

I'd be surprised if it stays that way after dealing with the above functions.

The problem is that statement.d has many dependencies. Even if we move out everything that relies on semantic information from statement.d, we will still have some Expression fields. expression.d has other dependencies that rely on semantic information, so now we need to the same for it too etc. My point is that, before we can simply do import statement; in ASTBase, we need to do this cleanup for all the AST nodes, otherwise the import dependencies are going to drag semantic information into ASTBase.